IBM Version 8.5
Manuali e guide per l''utente per IBM Version 8.5. Abbiamo trovato 2 manuali per download gratuiti Programming Guide, Manual
Below you will find brief information for PL/I for Windows Version 8.5. This document provides a comprehensive guide to using the PL/I for Windows compiler to code and compile PL/I programs. It covers topics such as porting applications between platforms, compiling and linking your program, running and debugging your program, input and output, using PL/I with databases, advanced topics, and appendixes.
Caratteristiche principali
Porting mainframe PL/I programs to Windows
Compiling and linking PL/I programs
Running and debugging PL/I programs
Using data sets and files
Using PL/I with databases
Building dynamic link libraries
Improving performance
Using user exits
Calling conventions
Interfacing with Java
pagine: 548 IBM Version 8.5 Programming Guide
Marca: IBM Categoria: Software Dimensione: 2 MB
Lingue: English
Indice
- 5 Contents
- 13 Tables
- 15 Figures
- 17 About this book
- 17 What's new?
- 17 How to read the syntax diagrams
- 19 How to send your comments
- 21 Part 1. Introducing PL/I on your workstation
- 23 Chapter 1. Porting applications between platforms
- 23 Getting mainframe applications to compile on the workstation
- 24 Choosing the right compile-time options
- 24 Language restricted
- 24 RECORD I/O
- 24 STREAM I/O
- 25 Structure expressions
- 25 Array expressions
- 25 DEFAULT statement
- 25 Extents of automatic variables
- 25 Built-in functions
- 26 iSUB defining
- 26 DBCS
- 26 Macro preprocessor
- 27 Using the macro facility to help port programs
- 27 Getting mainframe applications to run on the workstation
- 27 Linking differences
- 27 Data representations causing runtime differences
- 30 Environment differences affecting portability
- 31 Language elements causing runtime differences
- 33 Part 2. Compiling and linking your program
- 37 Chapter 2. Compiling your program
- 37 A short practice exercise
- 37 The HELLO program
- 38 Using compile-time options
- 38 Using the sample programs provided with the product
- 38 Preparing to compile source programs
- 38 Program file structure
- 38 Using a PROCEDURE statement with PROCESS:
- 39 INCLUDE processing
- 39 %LINE directive
- 40 Margins
- 40 Program file format
- 40 Line continuation
- 41 Setting compile-time environment variables
- 41 IBM.OPTIONS
- 42 IBM.PPINCLUDE
- 42 IBM.PPMACRO
- 42 IBM.PPSQL
- 42 IBM.PPCICS
- 43 IBM.SOURCE
- 43 IBM.SYSLIB
- 43 IBM.PRINT
- 43 IBM.OBJECT
- 43 IBM.DECK
- 44 INCLUDE
- 44 TMP
- 44 Using the PLI command to invoke the compiler
- 44 Where to specify compile-time options
- 45 IBM.OPTIONS and IBM.PPxxx environment variables
- 45 PLI command
- 45 %PROCESS statement
- 47 Chapter 3. Compile-time options
- 47 Compile-time option descriptions
- 50 Rules for using compile-time options
- 51 ADDEXT
- 52 AGGREGATE
- 53 ATTRIBUTES
- 54 BIFPREC
- 55 BLANK
- 56 CASERULES
- 57 CHECK
- 58 CMPAT
- 59 CODEPAGE
- 60 COMPILE
- 61 COPYRIGHT
- 62 CURRENCY
- 63 DBCS
- 64 DEFAULT
- 73 DEPRECATE
- 75 DEPRECATENEXT
- 76 DLLINIT
- 77 EXIT
- 78 EXTRN
- 79 FLAG
- 80 FLOATINMATH
- 81 GONUMBER
- 82 GRAPHIC
- 83 IGNORE
- 84 IMPRECISE
- 85 INCAFTER
- 86 INCLUDE
- 87 INITAUTO
- 88 INITBASED
- 89 INITCTL
- 90 INITSTATIC
- 91 INSOURCE
- 92 LANGLVL
- 93 LIBS
- 94 LIMITS
- 95 LINECOUNT
- 96 LINEDIR
- 97 LIST
- 98 LISTVIEW
- 100 MACRO
- 101 MARGINI
- 102 MARGINS
- 103 MAXGEN
- 104 MAXMSG
- 105 MAXNEST
- 106 MAXSTMT
- 107 MAXTEMP
- 108 MDECK
- 109 MSG
- 110 MSGSUMMARY
- 111 NAMES
- 112 NATLANG
- 113 NEST
- 114 NOT
- 115 NUMBER
- 116 OBJECT
- 117 OFFSET
- 118 ONSNAP
- 119 OPTIMIZE
- 120 OPTIONS
- 121 OR
- 122 PP
- 123 PPCICS
- 124 PPINCLUDE
- 125 PPLIST
- 126 PPMACRO
- 127 PPSQL
- 128 PPTRACE
- 129 PRECTYPE
- 130 PREFIX
- 131 PROBE
- 132 PROCEED
- 133 PROCESS
- 134 QUOTE
- 135 REDUCE
- 136 RESEXP
- 137 RESPECT
- 138 RULES
- 146 SEMANTIC
- 147 SNAP
- 148 SOSI
- 149 SOURCE
- 150 STATIC
- 151 STMT
- 152 STORAGE
- 153 SYNTAX
- 154 SYSPARM
- 155 SYSTEM
- 156 TERMINAL
- 157 TEST
- 158 USAGE
- 159 WIDECHAR
- 160 WINDOW
- 161 XINFO
- 164 XML
- 165 XREF
- 167 Chapter 4. PL/I preprocessors
- 167 Include preprocessor
- 167 Examples
- 168 Include preprocessor options environment variable
- 168 Macro preprocessor
- 168 Macro preprocessor options
- 170 Macro facility options environment variables
- 170 SQL preprocessor
- 170 Programming and compilation considerations
- 171 SQL preprocessor options
- 178 SQL preprocessor options environment variable
- 178 SQL preprocessor BIND environment variables
- 178 Coding SQL statements in PL/I applications
- 178 Defining the SQL communications area
- 179 Defining SQL descriptor areas
- 180 Embedding SQL statements
- 181 Using host variables
- 184 Determining equivalent SQL and PL/I data types
- 185 Determining compatibility of SQL and PL/I data types
- 185 Using host structures
- 186 Using indicator variables
- 186 Host structure example
- 187 Using statements and compile-time options
- 187 Large Object (LOB) support
- 187 Sample programs for LOB support
- 188 User defined functions sample programs
- 189 Handling SQL error return codes
- 190 SQL compatibility and migration considerations
- 190 CICS support
- 190 Programming and compilation considerations
- 192 CICS preprocessor options
- 192 CICS preprocessor options environment variables
- 193 Coding CICS statements in PL/I applications
- 193 Embedding CICS statements
- 193 Writing CICS transactions in PL/I
- 194 CICS abends used for PL/I programs
- 194 CICS run-time user exit
- 195 Chapter 5. Compilation output
- 195 Using the compiler listing
- 203 Compiler output files
- 205 Chapter 6. Linking your program
- 205 Starting the linker
- 205 Statically linking
- 205 Linking from the command line
- 206 Linking from a make file
- 207 Input and output
- 208 Search rules
- 208 Specifying directories
- 208 Filename defaults
- 209 Specifying object files
- 209 Using response files
- 210 Specifying executable output type
- 210 Producing an .EXE file
- 210 Producing a dynamic link library
- 211 Packing executables
- 211 Generating a map file
- 211 Linker return codes
- 213 Chapter 7. Setting linker options
- 213 Setting options on the command line
- 213 Setting options in the ILINK environment variable
- 213 Using the linker
- 214 Specifying numeric arguments
- 214 Summary of Windows linker options
- 215 Windows linker options
- 215 /?
- 215 /ALIGNADDR
- 216 /ALIGNFILE
- 216 /BASE
- 216 /CODE
- 217 /DATA
- 217 /DBGPACK, /NODBGPACK
- 217 /DEBUG, /NODEBUG
- 217 /DEFAULTLIBRARYSEARCH
- 218 /DLL
- 218 /ENTRY
- 218 /EXECUTABLE
- 219 /EXTDICTIONARY, /NOEXTDICTIONARY
- 219 /FIXED, /NOFIXED
- 219 /FORCE
- 219 /HEAP
- 219 /HELP
- 220 /INCLUDE
- 220 /INFORMATION, /NOINFORMATION
- 220 /LINENUMBERS, /NOLINENUMBERS
- 220 /LOGO, /NOLOGO
- 221 /MAP, /NOMAP
- 221 /OUT
- 221 /PMTYPE
- 221 /SECTION
- 222 /SEGMENTS
- 222 /STACK
- 223 /STUB
- 223 /SUBSYSTEM
- 223 /VERBOSE
- 223 /VERSION
- 225 Part 3. Running and debugging your program
- 227 Chapter 8. Using run-time options
- 227 Setting run-time environment variables
- 227 PATH
- 227 DPATH
- 227 Specifying run-time options
- 227 Where to specify run-time options
- 228 Specifying multiple run-time options or suboptions
- 228 Run-time options
- 228 NATLANG
- 229 Shipping run-time DLLs
- 231 Chapter 9. Testing and debugging your programs
- 231 Testing your programs
- 232 General debugging tips
- 233 PL/I debugging techniques
- 233 Using compile-time options for debugging
- 234 Using footprints for debugging
- 235 Using dumps for debugging
- 235 Formatted PL/I dumps—PLIDUMP
- 239 SNAP dumps for trace information
- 239 Using error and condition handling for debugging
- 239 Error and condition handling terminology
- 240 Error handling concepts
- 240 System facilities
- 240 Language facilities
- 242 ON-units for qualified and unqualified conditions
- 242 Conditions used for testing and debugging
- 242 Common programming errors
- 242 Logical errors in your source programs
- 242 Invalid use of PL/I
- 243 Calling uninitialized entry variables
- 243 Loops and other unforeseen errors
- 244 Tips for dealing with loops
- 244 Unexpected input/output data
- 244 Unexpected program termination
- 245 Other unexpected program results
- 245 Compiler or library subroutine failure
- 245 System failure
- 246 Poor performance
- 247 Part 4. Input and output
- 249 Chapter 10. Using data sets and files
- 249 Types of data sets
- 250 Native data sets
- 250 Conventional text files and devices
- 250 Fixed-length data sets
- 251 Additional data sets
- 251 Varying-length data sets
- 251 Regional data sets
- 251 Workstation VSAM data sets
- 252 Establishing data set characteristics
- 252 Records
- 253 Record formats
- 253 Data set organizations
- 253 Specifying characteristics using the PL/I ENVIRONMENT attribute
- 253 CONSECUTIVE
- 254 CTLASA
- 254 GENKEY
- 256 GRAPHIC
- 256 KEYLENGTH
- 256 KEYLOC
- 257 ORGANIZATION
- 257 RECSIZE
- 258 REGIONAL(1)
- 258 SCALARVARYING
- 259 VSAM
- 259 Specifying characteristics using DD:ddname environment variables
- 259 AMTHD
- 260 APPEND
- 260 ASA
- 261 AUTOPAGE
- 261 BUFSIZE
- 261 CHARSET for record I/O
- 262 CHARSET for stream I/O
- 262 DELAY
- 262 DELIMIT
- 262 LRECL
- 263 LRMSKIP
- 263 PROMPT
- 263 PUTPAGE
- 264 RECCOUNT
- 264 RECSIZE
- 264 RETRY
- 264 SAMELINE
- 265 SHARE
- 265 SKIP0
- 266 TERMLBUF
- 266 TYPE
- 268 Associating a PL/I file with a data set
- 268 Using environment variables
- 269 Using the TITLE option of the OPEN statement
- 270 Attempting to use files not associated with data sets
- 270 How PL/I finds data sets
- 270 Opening and closing PL/I files
- 270 Opening a file
- 270 Closing a file
- 270 Associating several data sets with one file
- 271 Combinations of I/O statements, attributes, and options
- 273 DISPLAY statement input and output
- 274 PL/I standard files (SYSPRINT and SYSIN)
- 274 Redirecting standard input, output, and error devices
- 275 Chapter 11. Defining and using consecutive data sets
- 275 Printer-destined files
- 276 Using stream-oriented data transmission
- 276 Defining files using stream I/O
- 277 ENVIRONMENT options for stream-oriented data transmission
- 277 Creating a data set with stream I/O
- 277 Essential information
- 278 Example
- 279 Accessing a data set with stream I/O
- 280 Essential information
- 280 Example
- 281 Using PRINT files
- 282 Controlling printed line length
- 284 Overriding the tab control table
- 285 Using SYSIN and SYSPRINT files
- 285 Controlling input from the terminal
- 286 Using files conversationally
- 286 Format of data
- 287 Stream and record files
- 287 Capital and lowercase letters
- 287 End of file
- 288 Controlling output to the terminal
- 288 Format of PRINT files
- 288 Stream and record files
- 288 Example of an interactive program
- 289 Using record-oriented I/O
- 290 Defining files using record I/O
- 291 ENVIRONMENT options for record-oriented data transmission
- 291 Creating a data set with record I/O
- 291 Essential information
- 291 Accessing and updating a data set with record I/O
- 292 Essential information
- 292 Examples of consecutive data sets
- 297 Chapter 12. Defining and using regional data sets
- 299 Defining files for a regional data set
- 299 Specifying ENVIRONMENT options
- 299 Essential information for creating and accessing regional data sets
- 300 Using keys with regional data sets
- 300 Using REGIONAL(1) data sets
- 300 Dummy records
- 300 Creating a REGIONAL(1) data set
- 301 Example
- 302 Accessing and updating a REGIONAL(1) data set
- 302 Sequential access
- 303 Direct access
- 303 Example
- 307 Chapter 13. Defining and using workstation VSAM data sets
- 307 Moving data between the workstation and mainframe
- 307 Workstation VSAM organization
- 308 Creating and accessing workstation VSAM data sets
- 308 Determining which type of workstation VSAM data set you need
- 308 Accessing records in workstation VSAM data sets
- 309 Using keys for workstation VSAM data sets
- 309 Using keys for workstation VSAM keyed data sets
- 310 Using sequential record values
- 310 Using relative record numbers
- 310 Choosing a data set type
- 312 Defining files for workstation VSAM data sets
- 312 Specifying options of the PL/I ENVIRONMENT attribute
- 313 Adapting existing programs for workstation VSAM
- 313 Adapting programs using CONSECUTIVE files
- 313 Adapting programs using INDEXED files
- 314 Adapting programs using REGIONAL(1) files
- 314 Adapting programs using VSAM files
- 315 Using workstation VSAM sequential data sets
- 316 Using a sequential file to access a workstation VSAM sequential data set
- 316 Defining and loading a workstation VSAM sequential data set
- 318 Updating a sequential data set
- 318 Workstation VSAM keyed data sets
- 320 Loading a workstation VSAM keyed data set
- 322 Using a SEQUENTIAL file to access a workstation VSAM keyed data set
- 322 Using a DIRECT file to access a workstation VSAM keyed data set
- 325 Workstation VSAM direct data sets
- 327 Loading a workstation VSAM direct data set
- 329 Using a SEQUENTIAL file to access a workstation VSAM direct data set
- 329 Using READ statements
- 329 Using WRITE statements
- 329 Using the REWRITE or DELETE statements
- 329 Using a DIRECT file to access a workstation VSAM direct data set
- 333 Part 5. Using PL/I with databases
- 335 Chapter 14. Open Database Connectivity
- 335 Introducing ODBC
- 335 Background
- 335 ODBC Driver Manager
- 335 Choosing embedded SQL or ODBC
- 336 Using the ODBC drivers
- 336 Online help
- 336 Environment-specific information
- 336 Driver names
- 336 Configuring data sources
- 337 Connecting to a data source
- 337 Using a logon dialog box
- 337 Using a connection string
- 337 Error messages
- 338 ODBC APIs from PL/I
- 339 CALL interface convention
- 339 Using the supplied include files
- 340 Mapping of ODBC C types
- 341 Setting licensing information for ODBC Driver Manager/driver
- 341 Sample program using supplied include files
- 343 Chapter 15. Using java Dclgen
- 343 Understanding java Dclgen terminology
- 344 PL/I java Dclgen support
- 344 Creating a table declaration and host structure
- 345 Selecting a database
- 345 Selecting a table and generation a PL/I declaration
- 346 Modifying and saving the generated PL/I declaration
- 347 Exiting java Dclgen
- 347 Including data declarations in your program
- 349 Part 6. Advanced topics
- 353 Chapter 16. Using the Program Maintenance Utility, NMAKE
- 353 Why use NMAKE?
- 353 Running NMAKE
- 353 Using the command line
- 353 Command-line syntax
- 354 Command-line help
- 354 Using NMAKE command files
- 354 Why use a command file?
- 355 Command file syntax
- 355 Example
- 355 NMAKE options
- 355 Produce error file (/X)
- 355 Build all targets (/A)
- 355 Suppress messages (/C)
- 356 Display modification dates (/D)
- 356 Override environment variables (/E)
- 356 Specify description file (/F)
- 356 Display help (/HELP or /?)
- 356 Ignore exit codes (/I)
- 356 Display commands (/N)
- 356 Suppress sign-on banner (/NOLOGO)
- 357 Print macro and target definitions (/P)
- 357 Return exit code (/Q)
- 357 Ignore TOOLS.INI file (/R)
- 357 Suppress command display (/S)
- 357 Change target modification dates (/T)
- 357 Description files
- 358 Description blocks
- 358 Special features
- 359 Targets in several description blocks
- 360 Using macros
- 360 Macros example
- 360 Special features
- 360 Macros in a description file
- 361 Macros on the command line
- 361 Inherited macros
- 361 Defined macros
- 362 Macro substitutions
- 362 Special macros
- 363 Special macros examples
- 364 File-specification parts
- 364 Characters that modify special macros
- 364 Modified special macros example
- 364 Macro precedence rules
- 365 Inference rules
- 366 Special features
- 366 Inference rules example
- 366 Inference-rule path specifications
- 367 Predefined inference rules
- 367 Directives
- 369 Directives example
- 369 Pseudotargets
- 369 Predefined pseudotargets
- 369 .SILENT Pseudotarget
- 369 .IGNORE Pseudotarget
- 370 .SUFFIXES Pseudotarget
- 370 .PRECIOUS Pseudotarget
- 370 Inline files
- 371 Inline files example
- 371 Escape characters
- 372 Characters that modify commands
- 372 Turn error checking off (-)
- 372 Dash command modifier examples
- 373 Suppress command display (@)
- 373 At sign (@) command modifier example
- 373 Execute command for dependents (!)
- 373 Exclamation point (!) command modifier examples
- 374 EXTMAKE Syntax
- 374 Macros and inference rules in TOOLS.INI
- 374 TOOLS.INI example
- 375 Chapter 17. Improving performance
- 375 Selecting compile-time options for optimal performance
- 375 OPTIMIZE
- 375 IMPRECISE
- 376 GONUMBER
- 376 SNAP
- 376 RULES
- 377 PREFIX
- 377 CONVERSION
- 377 FIXEDOVERFLOW
- 377 DEFAULT
- 378 BYADDR or BYVALUE
- 379 (NON)CONNECTED
- 379 RETURNS(BYVALUE) or RETURNS(BYADDR)
- 379 (NO)DESCRIPTOR
- 379 (RE)ORDER
- 379 LINKAGE
- 380 ASCII or EBCDIC
- 380 IEEE or HEXADEC
- 380 (NON)NATIVE
- 380 (NO)INLINE
- 381 Summary of compile-time options that improve performance
- 381 Coding for better performance
- 381 DATA-directed input and output
- 382 Input-only parameters
- 382 String assignments
- 382 Loop control variables
- 383 PACKAGEs versus nested PROCEDUREs
- 383 Example with nested procedures
- 384 REDUCIBLE functions
- 384 DEFINED versus UNION
- 385 Named constants versus static variables
- 385 Example with optimal code but no meaningful names
- 386 Avoiding calls to library routines
- 389 Chapter 18. Using user exits
- 389 Using the compiler user exit
- 389 Procedures performed by the compiler user exit
- 390 Activating the compiler user exit
- 390 The IBM-supplied compiler exit, IBMUEXIT
- 391 Customizing the compiler user exit
- 391 Modifying IBMUEXIT.INF
- 392 Writing your own compiler exit
- 392 Structure of global control blocks
- 393 Writing the initialization procedure
- 393 Writing the message filtering procedure
- 395 Writing the termination procedure
- 395 Using the CICS run-time user exit
- 396 Prior to program invocation
- 396 After program termination
- 396 Modifying CEEFXITA
- 396 Using data conversion tables
- 399 Chapter 19. Building dynamic link libraries
- 399 Creating DLL source files
- 399 Compiling your DLL source
- 400 Preparing to link your DLL
- 400 Specifying exported names under Windows
- 400 Linking your DLL
- 400 Using your DLL
- 401 Sample program to build a DLL
- 401 Using FETCH and RELEASE in your main program
- 402 Exporting data from a DLL
- 403 Chapter 20. Using IBM Library Manager on Windows
- 403 Running ILIB
- 403 Using the command line
- 404 Using the ILIB environment variable
- 404 Command line
- 404 Windows control panel
- 405 Windows 98 AUTOEXEC.BAT file
- 405 Using an ILIB response file
- 405 Examples specifying ILIB parameters
- 406 Controlling ILIB input
- 406 Controlling ILIB output
- 407 Controlling ILIB output
- 408 ILIB objects
- 408 Summary of ILIB objects
- 408 Add/Replace
- 409 /EXTRACT
- 410 /REMOVE
- 410 ILIB options
- 410 Summary of ILIB options
- 411 /?
- 411 /BACKUP
- 411 /DEF
- 412 /FREEFORMAT
- 412 /GENDEF
- 412 /GI
- 412 /HELP
- 413 /LIST
- 413 /NOEXT
- 413 /OUT
- 413 /QUIET
- 413 /WARN
- 415 Chapter 21. Calling conventions
- 415 Understanding linkage considerations
- 416 OPTLINK linkage
- 416 Features of OPTLINK
- 417 Tips for using OPTLINK
- 417 General-purpose register implications
- 417 Parameters
- 418 Examples of passing parameters
- 418 Passing conforming parameters to a routine
- 423 SYSTEM linkage
- 423 Features of SYSTEM
- 424 Example using SYSTEM linkage
- 425 STDCALL linkage (Windows only)
- 426 Features of STDCALL
- 426 Examples using the STDCALL convention
- 428 Using WinMain (Windows only)
- 428 CDECL linkage
- 428 Features of CDECL
- 429 Examples using the CDECL convention
- 431 Chapter 22. Using PL/I in mixed-language applications
- 431 Matching data and linkages
- 431 What data is passed
- 433 How data is passed
- 435 Where data is passed
- 435 Maintaining your environment
- 435 Invoking non-PL/I routines from a PL/I MAIN
- 436 Invoking PL/I routines from a non-PL/I main
- 436 Using ON ANYCONDITION
- 439 Chapter 23. Interfacing with Java
- 439 What is the Java Native Interface (JNI)?
- 440 JNI Sample Program #1 - 'Hello World'
- 440 Step 1: Writing the Java Program
- 440 Declare the Native Method
- 440 Load the Native Library
- 440 Write the Java Main Method
- 441 Step 2: Compiling the Java Program
- 441 Step 3: Writing the PL/I Program
- 441 Useful PL/I Compiler Options
- 441 Correct Form of PL/I Procedure Name and Procedure Statement
- 442 JNI Include File
- 442 The Complete PL/I Procedure
- 442 Step 4: Compiling and Linking the PL/I Program
- 442 Compiling the PL/I Program
- 442 Linking the Dynamic Link Library
- 443 Step 5: Running the Sample Program
- 443 JNI Sample Program #2 - Passing a String
- 443 Step 1: Writing the Java Program
- 443 Declare the Native Method
- 443 Load the Native Library
- 443 Write the Java Main Method
- 444 Step 2: Compiling the Java Program
- 445 Step 3: Writing the PL/I Program
- 445 Correct Form of PL/I Procedure Name and Procedure Statement
- 445 JNI Include File
- 445 The Complete PL/I Procedure
- 446 Step 4: Compiling and Linking the PL/I Program
- 446 Compiling the PL/I Program
- 447 Linking the Dynamic Link Library
- 447 Step 5: Running the Sample Program
- 447 JNI Sample Program #3 - Passing an Integer
- 447 Step 1: Writing the Java Program
- 447 Declare the Native Method
- 447 Load the Native Library
- 447 Write the Java Main Method
- 449 Step 2: Compiling the Java Program
- 449 Step 3: Writing the PL/I Program
- 449 Correct Form of PL/I Procedure Name and Procedure Statement
- 449 JNI Include File
- 449 The Complete PL/I Procedure
- 450 Step 4: Compiling and Linking the PL/I Program
- 450 Compiling the PL/I Program
- 450 Linking the Dynamic Link Library
- 451 Step 5: Running the Sample Program
- 451 Determining equivalent Java and PL/I data types
- 453 Chapter 24. Using sort routines
- 453 Comparing S/390 and workstation sort programs
- 454 Preparing to use sort
- 455 Choosing the type of sort
- 457 Specifying the sorting field
- 458 Example:
- 458 Specifying the records to be sorted
- 458 Example:
- 458 Calling the sort program
- 458 PLISRT examples
- 458 Example 1
- 459 Example 2
- 459 Example 3
- 459 Example 4
- 459 Determining whether the sort was successful
- 460 Getting diagnostic information
- 460 The IBM_SORT_RC environment variable
- 461 The IBM_SORT_DIR environment variable
- 461 The IBM_SORT_MSGFILE environment variable
- 461 Sort data input and output
- 461 Sort data handling routines
- 462 E15 — input-handling routine (sort exit E15)
- 464 E35 — output-handling routine (sort exit E35)
- 466 Calling PLISRTA
- 467 Calling PLISRTB
- 468 Calling PLISRTC
- 469 Calling PLISRTD, example 1
- 471 Calling PLISRTD, example 2
- 473 Chapter 25. Using the SAX parser
- 473 Overview
- 474 The PLISAXA built-in subroutine
- 474 The PLISAXB built-in subroutine
- 474 The SAX event structure
- 475 start_of_document
- 475 version_information
- 475 encoding_declaration
- 475 standalone_declaration
- 475 document_type_declaration
- 475 end_of_document
- 475 start_of_element
- 476 attribute_name
- 476 attribute_characters
- 476 attribute_predefined_reference
- 476 attribute_character_reference
- 476 end_of_element
- 476 start_of_CDATA_section
- 476 end_of_CDATA_section
- 477 content_characters
- 477 content_predefined_reference
- 477 content_character_reference
- 477 processing_instruction
- 477 comment
- 477 unknown_attribute_reference
- 478 unknown_content_reference
- 478 start_of_prefix_mapping
- 478 end_of_prefix_mapping
- 478 exception
- 478 Parameters to the event functions
- 479 Coded character sets for XML documents
- 479 Supported EBCDIC code pages
- 480 Supported ASCII code pages
- 480 Specifying the code page
- 480 Using a number:
- 480 Using an alias
- 481 Exceptions
- 482 Example
- 493 Continuable exception codes
- 497 Terminating exception codes
- 501 Chapter 26. Using PL/I MLE in your applications
- 501 Applying attributes and options
- 501 DATE attribute
- 502 RESPECT compile-time option
- 502 WINDOW compile-time option
- 502 RULES compile-time option
- 503 Understanding date patterns
- 503 Patterns and windowing
- 504 Using built-in functions with MLE
- 504 DAYS
- 505 DAYSTODATE
- 505 Performing date calculations and comparisons
- 505 Explicit date calculations
- 505 Comparing dates
- 505 Converting dates
- 506 Subtracting dates
- 506 Implicit date calculations
- 506 Implicit date comparisons
- 506 Comparing dates with like patterns
- 506 Comparing dates with differing patterns
- 507 Comparisons involving the DATE attribute and a literal
- 507 Comparisons involving the DATE attribute and a non-literal
- 507 Implicit DATE assignments
- 509 Part 7. Appendixes
- 511 Notices
- 512 Programming interface information
- 512 Macros for customer use
- 512 Trademarks
- 515 Bibliography
- 515 PL/I publications
- 515 PL/I for AIX
- 515 Enterprise PL/I publications
- 515 Related publications
- 515 DB2 UDB for OS/390 and z/OS
- 515 TXSeries for Multiplatforms
- 517 Glossary
- 535 Index
- 535 Special characters
- 535 A
- 535 B
- 535 C
- 536 D
- 538 E
- 538 F
- 539 G
- 539 H
- 539 I
- 539 J
- 539 K
- 540 L
- 540 M
- 540 N
- 541 O
- 541 P
- 542 Q
- 542 R
- 543 S
- 544 T
- 544 U
- 544 V
- 544 W
- 544 X
- 545 Readers’ Comments — We'd Like to Hear from You
Altri manuali e documenti
Risposte e domande frequenti
How do I port mainframe PL/I programs to Windows?
The document describes how to use compile-time options to make mainframe PL/I programs compatible with the Windows environment. It also covers techniques for addressing data representation differences and environment differences.
What are the steps involved in compiling and linking a PL/I program?
The document provides detailed instructions on compiling and linking PL/I programs using the provided compiler and linker. It explains how to set compile-time options, prepare source programs, and use the PLI command to invoke the compiler.
How do I debug PL/I programs on Windows?
The document explores various debugging techniques that are available, including compile-time options, footprints, dumps, and error handling. It also offers tips on common programming errors and how to prevent them.
What are the different types of data sets that PL/I can work with?
The document discusses native data sets, consecutive data sets, regional data sets, and workstation VSAM data sets. It explains how to define files for each type of data set and how to access and manipulate data within them.
How can I use PL/I with databases?
The document explores using Open Database Connectivity (ODBC) and embedded SQL to connect PL/I programs to databases. It covers topics such as connecting to a data source, using ODBC APIs, and handling error messages.
How do I create and use dynamic link libraries (DLLs) with PL/I?
The document provides a step-by-step guide to building DLLs in PL/I, including compiling DLL source files, linking DLLs, and using them in other applications. It explains how to export data and functions from DLLs.
annuncio pubblicitario